const app = getApp()
const api = require('../../utils/api')
const reviewApi = require('../../utils/reviewApi')

Page({
  data: {
    productId: null,
    product: null,
    quantity: 1,
    showSpecs: false,
    selectedSpec: null,
    isLoggedIn: false,
    showReviewModal: false,
    reviewContent: '',
    reviewRating: 5,
    uploadImages: [],
    currentTab: 0, // 0: 商品详情, 1: 用户评价
    fromPage: '', // 添加来源页面标记
    reviews: [],
    loading: true,
    showReplyModal: false,
    replyContent: '',
    rating: 0,
    currentReviewId: null,
    canReview: false,
    orderNo: null, // 订单编号
    page: 0,
    size: 10,
    hasMoreReviews: true,
    reviewPage: 1,
    reviewsLoading: true
  },

  onLoad(options) {
    console.log('商品详情页参数:', options);
    
    // 获取商品ID
    if (options.id) {
      const productId = options.id;
      this.loadProduct(productId);
      
      // 设置页面数据
      this.setData({
        productId,
        isLoggedIn: !!wx.getStorageSync('userInfo'),
        canReview: options.source === 'order' && options.orderNo,
        orderNo: options.orderNo || null,
        page: 0 // 评价页码重置为0
      });
      
      // 加载商品评价
      console.log('准备加载商品评价');
      setTimeout(() => {
        this.getProductReviews();
      }, 500); // 短暂延迟，确保商品信息已加载
    } else {
      wx.showToast({
        title: '缺少商品ID',
        icon: 'none'
      });
      setTimeout(() => {
        wx.navigateBack();
      }, 1500);
    }
  },

  onShow() {
    // 每次显示页面时检查登录状态
    this.setData({
      isLoggedIn: app.globalData.isLogin
    });
  },

  // 加载商品详情
  async loadProduct(id) {
    let loading = false;
    try {
      if (!loading) {
        loading = true;
        wx.showLoading({
          title: '加载中...',
          mask: true
        });
      }

      // 检查商品ID是否有效
      if (!id || id <= 0) {
        throw new Error('无效的商品ID');
      }

      console.log('开始加载商品，ID:', id);
      const res = await api.getProductDetail(id);
      console.log('商品详情响应:', res);
      
      if (res && res.success && res.data) {
        // 检查商品状态
        if (res.data.status !== 1) {
          throw new Error('商品已下架');
        }

        this.setData({
          product: res.data,
          loading: false
        });

        // 设置导航栏标题
        wx.setNavigationBarTitle({
          title: res.data.name
        });

        // 加载商品评论
        this.getProductReviews();
      } else {
        throw new Error(res.message || '加载商品失败');
      }
    } catch (error) {
      console.error('加载商品失败:', error);
      this.showError(error.message || '商品不存在或已下架');
    } finally {
      if (loading) {
        loading = false;
        wx.hideLoading();
      }
    }
  },

  // 加载商品评价
  async getProductReviews() {
    const { product, page, size } = this.data;
    
    if (!product || !product.id) {
      console.error('无法加载评价：商品ID为空');
      return;
    }
    
    try {
      console.log('开始加载商品评价，商品ID:', product.id, '页码:', page);
      wx.showLoading({ title: '加载评价中' });
      
      const res = await reviewApi.getProductReviews(product.id, page, size);
      console.log('商品评价API响应:', res);
      
      if (res.success) {
        const { content, last } = res.data;
        
        if (!content || !Array.isArray(content)) {
          throw new Error('返回数据格式不正确');
        }
        
        // 处理评价数据
        const formattedReviews = content.map(review => {
          console.log('处理评价数据，原始数据:', review);
          console.log('原始评论的imageUrls:', review.imageUrls);
          
          // 处理图片URL
          let imageUrls = [];
          if (review.imageUrls) {
            // 如果是字符串尝试解析
            if (typeof review.imageUrls === 'string') {
              try {
                imageUrls = JSON.parse(review.imageUrls);
                console.log('成功解析imageUrls JSON字符串:', imageUrls);
              } catch (e) {
                console.error('解析imageUrls字符串失败:', e, review.imageUrls);
                imageUrls = review.imageUrls.split(',').filter(url => url.trim() !== '');
                console.log('通过逗号分隔解析到的URL:', imageUrls);
              }
            } else if (Array.isArray(review.imageUrls)) {
              imageUrls = review.imageUrls;
              console.log('imageUrls已经是数组:', imageUrls);
            }
            
            // 处理URL格式
            imageUrls = imageUrls.map(url => {
              if (!url) return '';
              
              console.log('处理图片URL:', url);
              
              // 确保URL格式正确
              if (url.startsWith('http')) {
                return url;
              } else if (url.startsWith('/')) {
                // 如果是相对路径，添加基础URL
                return api.getBaseUrl() + url;
              } else {
                return api.getBaseUrl() + '/' + url;
              }
            }).filter(url => url); // 过滤空URL

            // 打印实际图片URL以进行调试
            console.log('实际图片URLs:', imageUrls.map(url => url));

            // 添加默认图片路径
            if (imageUrls.length === 0) {
              console.log('该评论没有图片或图片URL为空');
            }
          } else {
            console.log('评论没有imageUrls字段');
            
            // 尝试检查是否有其他字段可能包含图片URL
            if (review.images) {
              console.log('评论有images字段，尝试使用它:', review.images);
              if (Array.isArray(review.images)) {
                imageUrls = review.images;
              } else if (typeof review.images === 'string') {
                try {
                  imageUrls = JSON.parse(review.images);
                } catch (e) {
                  imageUrls = review.images.split(',').filter(url => url.trim() !== '');
                }
              }
            }
          }
          
          console.log('处理后的评论图片URLs:', imageUrls);
          
          return {
            id: review.id,
            userId: review.userId,
            username: review.username || '用户',
            userAvatar: review.userAvatar || '/images/default-avatar.png',
            rating: review.rating,
            content: review.content,
            imageUrls: imageUrls,
            createTime: this.formatTime(review.createTime),
            likesCount: review.likesCount || 0,
            isLiked: review.isLiked || false,
          };
        });
        
        console.log('格式化后的评价数据:', formattedReviews);
        
        // 设置数据前添加日志
        console.log('最终评论数据示例(第一条):', formattedReviews[0] || '无评论');

        // 特别检查图片URL
        if (formattedReviews.length > 0) {
          formattedReviews.forEach((review, idx) => {
            console.log(`评论${idx+1}的图片数量:`, review.imageUrls ? review.imageUrls.length : 0);
            if (review.imageUrls && review.imageUrls.length > 0) {
              console.log(`评论${idx+1}的第一张图片URL:`, review.imageUrls[0]);
            }
          });
        }

        this.setData({
          reviews: page === 0 ? formattedReviews : [...this.data.reviews, ...formattedReviews],
          hasMoreReviews: !last,
          reviewPage: page + 1,
          reviewsLoading: false
        }, () => {
          // 加载完成后额外检查并标准化所有URL
          this.ensureAllImageUrls();
        });
        
        // 更新评分统计
        if (page === 0 && typeof this.updateReviewStats === 'function') {
          this.updateReviewStats(formattedReviews);
        }
      } else {
        console.error('加载评价失败:', res.message);
        throw new Error(res.message || '加载评价失败');
      }
    } catch (error) {
      console.error('加载评价异常:', error);
      wx.showToast({
        title: error.message || '加载评价失败',
        icon: 'none'
      });
      this.setData({ reviewsLoading: false });
    } finally {
      wx.hideLoading();
    }
  },

  // 格式化时间
  formatTime(timeStr) {
    if (!timeStr) return '';
    try {
      // 首先尝试将日期格式标准化为iOS支持的格式
      // 替换空格为'T'，确保符合ISO 8601标准
      if (timeStr.includes(' ')) {
        timeStr = timeStr.replace(' ', 'T');
      }
      
      const date = new Date(timeStr);
      
      // 检查日期是否有效
      if (isNaN(date.getTime())) {
        console.error('无效的日期格式:', timeStr);
        return timeStr;
      }
      
      const year = date.getFullYear();
      const month = (date.getMonth() + 1).toString().padStart(2, '0');
      const day = date.getDate().toString().padStart(2, '0');
      return `${year}-${month}-${day}`;
    } catch (e) {
      console.error('时间格式化错误:', e);
      return timeStr;
    }
  },

  // 更新评论统计
  updateReviewStats(reviews) {
    if (!reviews || !Array.isArray(reviews)) {
      return;
    }
    
    // 初始化评分统计
    const counts = {
      total: reviews.length,
      rating5: 0,
      rating4: 0,
      rating3: 0,
      rating2: 0,
      rating1: 0
    };
    
    // 计算平均评分
    let totalScore = 0;
    
    reviews.forEach(review => {
      totalScore += review.rating || 0;
      
      // 按评分统计数量
      switch(review.rating) {
        case 5:
          counts.rating5++;
          break;
        case 4:
          counts.rating4++;
          break;
        case 3:
          counts.rating3++;
          break;
        case 2:
          counts.rating2++;
          break;
        case 1:
          counts.rating1++;
          break;
      }
    });
    
    // 计算平均分
    const averageRating = counts.total > 0 ? (totalScore / counts.total).toFixed(1) : '0.0';
    
    // 更新UI
    this.setData({
      reviewStats: {
        averageRating,
        totalCount: counts.total,
        counts
      }
    });
  },

  // 自定义返回
  customBack() {
    const { fromPage } = this.data
    if (fromPage) {
      wx.navigateBack()
    } else {
      wx.switchTab({
        url: '/pages/home/home'
      })
    }
  },

  // 切换标签
  switchTab(e) {
    const currentTab = e.currentTarget.dataset.tab;
    this.setData({ currentTab });
  },

  // 查看全部评价
  viewAllReviews() {
    wx.navigateTo({
      url: `/pages/reviews/reviews?productId=${this.data.product.id}`
    });
  },

  // 点赞评论
  async handleReviewLike(e) {
    const { reviewid } = e.currentTarget.dataset;
    const { reviews, isLoggedIn } = this.data;
    
    // 检查登录状态
    if (!isLoggedIn) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      return;
    }
    
    const reviewIndex = reviews.findIndex(r => r.id === reviewid);
    if (reviewIndex === -1) {
      console.error('未找到对应评价:', reviewid);
      return;
    }
    
    const review = reviews[reviewIndex];
    const isLiked = review.isLiked;
    
    try {
      console.log(`${isLiked ? '取消点赞' : '点赞'}评价, ID:`, reviewid);
      
      // 乐观更新UI
      const newReviews = [...reviews];
      newReviews[reviewIndex] = {
        ...review,
        isLiked: !isLiked,
        likesCount: isLiked ? Math.max(0, review.likesCount - 1) : review.likesCount + 1
      };
      
      this.setData({ reviews: newReviews });
      
      // 调用API
      const response = isLiked 
        ? await reviewApi.unlikeReview(reviewid)
        : await reviewApi.likeReview(reviewid);
      
      // 处理API响应
      if (!response.success) {
        // 恢复原状态
        newReviews[reviewIndex] = review;
        this.setData({ reviews: newReviews });
        
        wx.showToast({
          title: response.message || '操作失败',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('点赞操作失败:', error);
      
      // 恢复原状态
      const newReviews = [...reviews];
      newReviews[reviewIndex] = review;
      this.setData({ reviews: newReviews });
      
      wx.showToast({
        title: error.message || '操作失败',
        icon: 'none'
      });
    }
  },

  // 预览图片
  previewImage(e) {
    const { urls, current } = e.currentTarget.dataset;
    
    // 确保URLs存在
    if (!urls || !Array.isArray(urls) || urls.length === 0) {
      console.error('预览图片失败：无效的URLs', urls);
      return;
    }
    
    // 添加图片加载指示
    wx.showLoading({
      title: '加载图片...',
      mask: true
    });
    
    console.log('预览图片:', current);
    console.log('图片列表:', urls);
    
    // 使用小程序预览图片API
    wx.previewImage({
      urls: urls,
      current: current,
      success: () => {
        console.log('图片预览成功');
        wx.hideLoading();
      },
      fail: (err) => {
        console.error('图片预览失败:', err);
        wx.hideLoading();
        wx.showToast({
          title: '图片预览失败',
          icon: 'none'
        });
      }
    });
  },

  // 立即购买
  async buyNow() {
    if (!this.data.product) {
      return this.showError()
    }

    // 检查是否登录
    if (!app.globalData.isLogin) {
      wx.showModal({
        title: '提示',
        content: '请先登录',
        success: (res) => {
          if (res.confirm) {
            wx.navigateTo({
              url: '/pages/login/login'
            })
          }
        }
      })
      return
    }

    const { product, quantity } = this.data

    // 检查商品状态和库存
    if (product.status !== 1) {
      return this.showError()
    }

    if (product.stock < quantity) {
      wx.showToast({
        title: '库存不足',
        icon: 'none'
      })
      return
    }

    let loading = false;
    try {
      if (!loading) {
        loading = true;
        wx.showLoading({
          title: '处理中...',
          mask: true
        });
      }

      // 再次检查商品状态
      const checkRes = await api.getProductDetail(product.id);
      if (!checkRes.success || !checkRes.data) {
        throw new Error('商品不存在或已被删除');
      }

      const currentProduct = checkRes.data;
      if (currentProduct.status !== 1) {
        throw new Error('商品已下架');
      }

      if (currentProduct.stock < quantity) {
        throw new Error('商品库存不足');
      }

      // 构建购买商品信息
      const buyNowItem = {
        id: product.id,  // 使用实际的商品ID
        productId: product.id,
        name: product.name,
        image: product.imageUrl,
        price: product.price,
        quantity: quantity,
        selected: true
      }

      // 保存到本地存储
      wx.setStorageSync('buyNowItem', buyNowItem)

      // 跳转到订单确认页
      wx.navigateTo({
        url: '/pages/order/checkout/checkout?from=buyNow'
      })
    } catch (error) {
      console.error('立即购买失败:', error)
      wx.showToast({
        title: error.message || '操作失败',
        icon: 'none'
      })
    } finally {
      if (loading) {
        loading = false;
        wx.hideLoading();
      }
    }
  },

  // 加入购物车
  async addToCart() {
    if (!this.data.product) {
      return this.showError();
    }

    // 检查是否登录
    if (!app.globalData.isLogin) {
      wx.showModal({
        title: '提示',
        content: '请先登录',
        success: (res) => {
          if (res.confirm) {
            wx.navigateTo({
              url: '/pages/login/login'
            });
          }
        }
      });
      return;
    }

    const { product, quantity } = this.data;

    // 检查商品状态和库存
    if (product.status !== 1) {
      return this.showError('商品已下架');
    }

    if (product.stock < quantity) {
      wx.showToast({
        title: '库存不足',
        icon: 'none'
      });
      return;
    }

    let loading = false;
    try {
      if (!loading) {
        loading = true;
        wx.showLoading({
          title: '添加中...',
          mask: true
        });
      }

      // 先检查商品状态
      const checkRes = await api.getProductDetail(product.id);
      if (!checkRes.success || !checkRes.data) {
        throw new Error('商品不存在或已被删除');
      }

      const currentProduct = checkRes.data;
      if (currentProduct.status !== 1) {
        throw new Error('商品已下架');
      }

      if (currentProduct.stock < quantity) {
        throw new Error('商品库存不足');
      }

      // 添加到购物车
      const res = await api.addToCart({
        productId: product.id,
        quantity: quantity
      });

      if (res.success) {
        wx.showToast({
          title: '已添加到购物车',
          icon: 'success'
        });
      } else {
        throw new Error(res.message || '添加失败');
      }
    } catch (error) {
      console.error('添加到购物车失败:', error);
      wx.showToast({
        title: error.message || '添加失败',
        icon: 'none'
      });
    } finally {
      if (loading) {
        loading = false;
        wx.hideLoading();
      }
    }
  },

  // 增加数量
  increaseQuantity() {
    const { quantity, product } = this.data
    if (product && quantity < product.stock) {
      this.setData({
        quantity: quantity + 1
      })
    } else {
      wx.showToast({
        title: '库存不足',
        icon: 'none'
      })
    }
  },

  // 减少数量
  decreaseQuantity() {
    const { quantity } = this.data
    if (quantity > 1) {
      this.setData({
        quantity: quantity - 1
      })
    }
  },

  // 直接修改数量
  updateQuantity(e) {
    const value = parseInt(e.detail.value)
    const { product } = this.data
    
    if (isNaN(value) || value < 1) {
      this.setData({ quantity: 1 })
      return
    }

    if (product && value > product.stock) {
      this.setData({ quantity: product.stock })
      wx.showToast({
        title: '超出库存数量',
        icon: 'none'
      })
      return
    }

    this.setData({ quantity: value })
  },

  // 显示评论输入弹窗
  showReviewInput() {
    if (!this.data.isLoggedIn) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      return;
    }
    
    // 检查是否有权限评价（是否从订单页面跳转来）
    if (!this.data.canReview) {
      wx.showToast({
        title: '只能对已购买的商品进行评价',
        icon: 'none'
      });
      return;
    }
    
    this.setData({
      showReviewModal: true,
      reviewContent: '',
      reviewRating: 5,
      uploadImages: []
    });
  },

  // 隐藏评论输入弹窗
  hideReviewModal() {
    this.setData({
      showReviewModal: false
    });
  },

  // 设置评分
  setRating(e) {
    this.setData({
      reviewRating: e.currentTarget.dataset.rating
    });
  },

  // 选择图片
  async chooseImage() {
    try {
      const res = await new Promise((resolve, reject) => {
        wx.chooseImage({
          count: 9 - this.data.uploadImages.length,
          sizeType: ['compressed'],
          sourceType: ['album', 'camera'],
          success: resolve,
          fail: reject
        });
      });

      const tempFilePaths = res.tempFilePaths;
      const uploadImages = [...this.data.uploadImages, ...tempFilePaths];
      
      this.setData({ uploadImages });
    } catch (error) {
      console.error('选择图片失败:', error);
    }
  },

  // 移除图片
  removeImage(e) {
    const { index } = e.currentTarget.dataset;
    const uploadImages = [...this.data.uploadImages];
    uploadImages.splice(index, 1);
    this.setData({ uploadImages });
  },

  // 提交评论
  async submitReview() {
    // 先隐藏可能存在的加载状态
    wx.hideLoading();
    
    try {
      const { reviewContent, reviewRating, productId, uploadImages, orderNo } = this.data;
      
      if (!reviewContent.trim()) {
        wx.showToast({
          title: '请输入评论内容',
          icon: 'none'
        });
        return;
      }
      
      if (reviewRating < 1) {
        wx.showToast({
          title: '请选择评分',
          icon: 'none'
        });
        return;
      }
      
      // 检查是否有权限评价
      if (!this.data.canReview || !orderNo) {
        wx.showToast({
          title: '只能对已购买的商品进行评价',
          icon: 'none'
        });
        return;
      }
      
      // 显示加载状态
      wx.showLoading({
        title: '提交中...',
        mask: true
      });
      
      // 准备评论数据
      const reviewData = {
        content: reviewContent,
        rating: reviewRating,
        orderNo: orderNo, // 添加订单编号
        productId: productId // 确保包含商品ID
      };
      
      // 如果有图片，先上传
      if (uploadImages && uploadImages.length > 0) {
        wx.showLoading({
          title: '上传图片中...',
          mask: true
        });
        
        console.log(`开始上传${uploadImages.length}张图片`);
        const imageUrls = [];
        let uploadSuccess = true;
        
        for (let i = 0; i < uploadImages.length; i++) {
          try {
            console.log(`开始上传第${i+1}张图片`);
            const uploadResult = await api.uploadImage(uploadImages[i]);
            console.log(`图片${i+1}上传结果:`, uploadResult);
            
            if (uploadResult && uploadResult.success && uploadResult.data && uploadResult.data.url) {
              const imageUrl = uploadResult.data.url;
              console.log(`图片${i+1}上传成功，URL:`, imageUrl);
              imageUrls.push(imageUrl);
            } else {
              console.error(`图片${i+1}上传失败:`, uploadResult);
              uploadSuccess = false;
            }
          } catch (error) {
            console.error(`图片${i+1}上传出错:`, error);
            uploadSuccess = false;
          }
        }
        
        if (!uploadSuccess) {
          wx.showToast({
            title: '部分图片上传失败',
            icon: 'none'
          });
        }
        
        console.log(`图片上传完成，共${imageUrls.length}张成功`);
        reviewData.imageUrls = imageUrls;
        
        // 隐藏图片上传的加载提示
        wx.hideLoading();
      }
      
      console.log('准备提交评论数据:', JSON.stringify(reviewData));
      
      // 重新显示提交评论的加载提示
      wx.showLoading({
        title: '提交评论中...',
        mask: true
      });
      
      // 使用api.submitReview方法替代直接调用request
      const res = await api.submitReview(reviewData);
      
      console.log('评论提交结果:', res);
      
      if (res.success) {
        wx.showToast({
          title: '评价成功',
          icon: 'success'
        });
        
        // 隐藏评论弹窗
        this.setData({
          showReviewModal: false,
          reviewContent: '',
          reviewRating: 5,
          uploadImages: []
        });
        
        // 刷新评论列表
        setTimeout(() => {
          this.setData({ page: 0 }); // 重置页码
          this.getProductReviews();
        }, 500);
        
        // 如果是从订单页面来的，返回订单页面
        if (this.data.fromPage === 'order' && this.data.orderNo) {
          setTimeout(() => {
            wx.navigateBack();
          }, 1500);
        }
      } else {
        wx.showToast({
          title: res.message || '评价失败',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('提交评论失败:', error);
      wx.showToast({
        title: error.message || '评价失败',
        icon: 'none'
      });
    } finally {
      // 确保隐藏加载状态
      setTimeout(() => {
        wx.hideLoading();
      }, 500);
    }
  },

  // 显示错误提示
  showError(message = '商品不存在或已下架') {
    this.setData({
      loading: false,
      product: null
    });
    
    // 显示错误提示
    wx.showToast({
      title: message,
      icon: 'none',
      duration: 2000
    });

    // 如果是从其他页面跳转来的，2秒后返回
    if (this.data.fromPage) {
      setTimeout(() => {
        wx.navigateBack();
      }, 2000);
    }
  },

  // 跳转到登录页
  goToLogin() {
    wx.navigateTo({
      url: '/pages/login/login'
    })
  },

  // 图片加载错误处理
  handleImageError(e) {
    console.error('图片加载失败:', e);
    const { reviewIndex, imageIndex } = e.currentTarget.dataset;
    
    // 记录日志，帮助调试
    const reviews = this.data.reviews;
    if (!reviews || !reviews[reviewIndex]) {
      console.error('无效的reviewIndex或reviews数组:', reviewIndex);
      return;
    }
    
    const review = reviews[reviewIndex];
    if (!review.imageUrls || !Array.isArray(review.imageUrls)) {
      console.error(`评论${reviewIndex}的imageUrls无效:`, review.imageUrls);
      return;
    }
    
    const imageUrl = review.imageUrls[imageIndex];
    console.error(`评论${reviewIndex}中索引${imageIndex}的图片加载失败，URL:`, imageUrl);
    
    // 尝试记录所有该评论的图片URLs，用于比较
    console.error(`评论${reviewIndex}所有图片URLs:`, JSON.stringify(review.imageUrls));
    console.error(`整个评论对象:`, JSON.stringify(review));
    
    // 检查图片URL是否有效格式
    if (!imageUrl) {
      console.error('图片URL为空');
      return;
    }
    
    // 尝试修复URL格式问题
    let fixedUrl = imageUrl;
    const baseUrl = api.getBaseUrl();
    
    // 1. 检查是否是后端返回的相对路径
    if (!imageUrl.startsWith('http')) {
      fixedUrl = baseUrl + (imageUrl.startsWith('/') ? imageUrl : '/' + imageUrl);
      console.log('尝试修复为完整URL:', fixedUrl);
    } 
    // 2. 检查是否有双斜杠问题(常见错误)
    else if (imageUrl.includes('//uploads')) {
      fixedUrl = imageUrl.replace('//uploads', '/uploads');
      console.log('修复双斜杠问题:', fixedUrl);
    }
    // 3. 检查是否使用了错误的协议
    else if (imageUrl.startsWith('https:') && baseUrl.startsWith('http:')) {
      fixedUrl = 'http:' + imageUrl.substring(6);
      console.log('修复协议问题:', fixedUrl);
    }
    // 4. 检查URL是否缺少域名
    else if (imageUrl.startsWith('/uploads')) {
      fixedUrl = baseUrl + imageUrl;
      console.log('添加域名到URL:', fixedUrl);
    }
    
    // 如果URL被修复了，更新数组
    if (fixedUrl !== imageUrl) {
      const newReviews = [...reviews];
      newReviews[reviewIndex].imageUrls[imageIndex] = fixedUrl;
      
      this.setData({
        reviews: newReviews
      });
      
      console.log('已更新图片URL:', fixedUrl);
    } else {
      console.log('URL看起来格式正确，但仍无法加载:', imageUrl);
      console.log('请检查服务器文件是否存在，或CORS配置是否正确');
    }
  },

  // 确保所有评论图片的URL格式正确
  ensureAllImageUrls() {
    const { reviews } = this.data;
    if (!reviews || !Array.isArray(reviews) || reviews.length === 0) {
      return;
    }

    console.log('开始检查并修复所有评论的图片URL');
    let hasChanges = false;
    const newReviews = [...reviews];
    const baseUrl = api.getBaseUrl();

    // 遍历所有评论和图片，确保URL格式正确
    newReviews.forEach((review, reviewIndex) => {
      console.log(`检查评论${reviewIndex}的数据:`, JSON.stringify(review));
      
      // 检查imageUrls是否存在
      if (!review.imageUrls) {
        console.log(`评论${reviewIndex}没有imageUrls字段`);
        // 尝试从其他字段提取图片URL
        if (review.images) {
          console.log(`评论${reviewIndex}有images字段，尝试使用它`);
          review.imageUrls = Array.isArray(review.images) ? review.images : [];
          hasChanges = true;
        } else {
          review.imageUrls = [];
          hasChanges = true;
        }
      } else if (typeof review.imageUrls === 'string') {
        // 尝试解析字符串格式的imageUrls
        console.log(`评论${reviewIndex}的imageUrls是字符串:`, review.imageUrls);
        try {
          review.imageUrls = JSON.parse(review.imageUrls);
          hasChanges = true;
        } catch (e) {
          review.imageUrls = review.imageUrls.split(',').filter(url => url.trim() !== '');
          hasChanges = true;
        }
      }
      
      if (!Array.isArray(review.imageUrls)) {
        console.log(`评论${reviewIndex}的imageUrls不是数组，设置为空数组`);
        review.imageUrls = [];
        hasChanges = true;
        return;
      }

      // 检查并修复每个URL
      review.imageUrls.forEach((url, imageIndex) => {
        if (!url) {
          return;
        }

        let fixedUrl = url;
        // 修复URL格式
        if (!url.startsWith('http')) {
          fixedUrl = baseUrl + (url.startsWith('/') ? url : '/' + url);
          hasChanges = true;
        } else if (url.includes('//uploads')) {
          fixedUrl = url.replace('//uploads', '/uploads');
          hasChanges = true;
        } else if (url.startsWith('https:') && baseUrl.startsWith('http:')) {
          fixedUrl = 'http:' + url.substring(6);
          hasChanges = true;
        }

        if (fixedUrl !== url) {
          console.log(`修正评论${reviewIndex}的图片${imageIndex}的URL:`, url, ' -> ', fixedUrl);
          newReviews[reviewIndex].imageUrls[imageIndex] = fixedUrl;
        }
      });
    });

    // 只有在有变更时才更新数据
    if (hasChanges) {
      console.log('有图片URL被修正，更新数据');
      this.setData({ reviews: newReviews });
    } else {
      console.log('所有图片URL格式正确，无需更新');
    }
  },
})
